One way in which data text may be cryptographically transformed is by modular exponentiation.
Such exponentiation involves determining the remainder when dividing a positive base integer y, which is raised to the e-th power by an exponent e, by a positive integer, i.e. a modulus z.
In other words the calculation takes the formx=ye(mod z)
A modular exponentiation calculation as set out above is relatively easy to do, even if the numbers involved are very large.
However, determining the discrete logarithm, i.e. finding exponent e given the base integer y, the remainder x, and the modulus z is very difficult. This one way functionality makes modular exponentiation very useful in cryptography.
One field of cryptography in which modular exponentiation is used is public-key cryptography, such as RSA (Rivest, Shamir and Adleman) public-key cryptography.
RSA cryptography utilises modular exponentiation to cryptographically transform data text to both encrypt the data text and decrypt the data text.
RSA cryptography first involves the step of key generation which includes determination of a public key and a private key. The public key can be known to everyone and is used for encrypting messages. Messages encrypted with the public key can only be decrypted using the private key.
The public key consists of a modulus z and a public encryption exponent e. The private key consists of the modulus z and a private decryption exponent d which must be kept secret.
To encrypt a message M it is first necessary to turn M into an integer, i.e. a data text y, using an agreed-upon reversible protocol, such as a padding scheme.
A first cryptographic transformation, i.e. an encryption transformation, involves generating an integer representation x of the data text y according tox=ye(mod z)
The integer representation x is an encrypted cipher text which can be transmitted to a recipient.
An intended recipient can recover the original data texty by carrying out a second cryptographic transformation, i.e. a decryption transformation, on the encrypted data text x.
The second cryptographic transformation involves generating an integer representation of the encrypted data text x using the private decryption exponent d by the following computationy=xd(mod z)
Accordingly, it is possible to recover the original data text y from the encrypted data text x.
Given the further integer representation, i.e. original data texty, it is possible to recover the original message M by reversing the agreed-upon reversible protocol.
Other cryptographic-related tasks such as, for example, agreeing on a cryptographic key, constructing a digital signature, and verifying such a signature, also utilize modular exponentiation, or exponentiation within another mathematical structure, for example, the group of points on an elliptic curve.
Such tasks typically look to generate an integer representation x of an original data text y, and so employ an exponential computation similar to that in the first cryptographic transformation mentioned above, i.e.x=ye 
In each of the aforementioned cases the exponentiation calculation, i.e. x=ye, can be computed using, for example, a square-and-multiply algorithm for modular exponentiation. Such computations require the manipulation of only two elements, i.e. the preceding iteration and the integer 1. As a result only two memory elements are required.
However such a calculation requires a large number of computational operations and so takes a finite amount of time to complete.
In many instances the time taken to complete the computational operations results in a delay that is perceptible by a user.
Accordingly it is desirable to reduce the time taken to complete the computational operations required, and hence the time required to complete a cryptographic task such as encrypting data text or decrypting data text.
One way of increasing the speed with which the integer representation x is generated is to employ unconstrained iterations in the exponentiation calculation, i.e. in calculating x=ye.
However such an approach requires storage of a large number of the iterations which results in the required number of memory elements being prohibitively large.
There is, therefore, a need to reduce the time taken to cryptographically transform a data text while maintaining the low memory requirements associated with conventional square-and-multiply modular exponentiation.